/*
** Lua binding: eTest
** Generated automatically by tolua++-1.0.92
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "../tolua++/tolua++.h"

/* Exported function */
TOLUA_API int  tolua_eTest_open (lua_State* tolua_S);

#include "../Log/TLog.h"
#include "../CustomAction/MyCustomAction.h"
#include "../CustomAction/MyNumber.h"
#include "../CustomAction/MyString.h"
#include "../CustomAction/MyArrayValue.h"
#include "../CustomAction/MyTemplateArray.h"
#include "../CustomAction/MySpecialAccess.h"
#include "../Adapter/ArrayValue.h"
#include "../toLuaEasy.h"
#include "LuaVM.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_MyMessage (lua_State* tolua_S)
{
 MyMessage* self = (MyMessage*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_MyNumber (lua_State* tolua_S)
{
 MyNumber* self = (MyNumber*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_ArrayValue (lua_State* tolua_S)
{
 ArrayValue* self = (ArrayValue*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_MyString (lua_State* tolua_S)
{
 MyString* self = (MyString*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_MyTemplateArray_MyString_ (lua_State* tolua_S)
{
 MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_MyTemplateArray_int_ (lua_State* tolua_S)
{
 MyTemplateArray<int>* self = (MyTemplateArray<int>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_MyTemplateArray_float_ (lua_State* tolua_S)
{
 MyTemplateArray<float>* self = (MyTemplateArray<float>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"MyTemplateArray<MyString>");
 tolua_usertype(tolua_S,"IArrayValue");
 tolua_usertype(tolua_S,"MyString");
 tolua_usertype(tolua_S,"GameApplication");
 tolua_usertype(tolua_S,"MyTemplateArray<int>");
 tolua_usertype(tolua_S,"ArrayValue");
 tolua_usertype(tolua_S,"MyMessage");
 tolua_usertype(tolua_S,"MyNumber");
 tolua_usertype(tolua_S,"LuaVM");
 tolua_usertype(tolua_S,"MyTemplateArray<float>");
}

/* get function: m_Inumber of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_get_MyNumber_m_Inumber
static int tolua_get_MyNumber_m_Inumber(lua_State* tolua_S)
{
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Inumber'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_Inumber);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_Inumber of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_set_MyNumber_m_Inumber
static int tolua_set_MyNumber_m_Inumber(lua_State* tolua_S)
{
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Inumber'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_Inumber = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_Fnumber of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_get_MyNumber_m_Fnumber
static int tolua_get_MyNumber_m_Fnumber(lua_State* tolua_S)
{
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Fnumber'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_Fnumber);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_Fnumber of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_set_MyNumber_m_Fnumber
static int tolua_set_MyNumber_m_Fnumber(lua_State* tolua_S)
{
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Fnumber'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_Fnumber = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_Dnumber of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_get_MyNumber_m_Dnumber
static int tolua_get_MyNumber_m_Dnumber(lua_State* tolua_S)
{
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Dnumber'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_Dnumber);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_Dnumber of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_set_MyNumber_m_Dnumber
static int tolua_set_MyNumber_m_Dnumber(lua_State* tolua_S)
{
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Dnumber'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_Dnumber = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_new00
static int tolua_eTest_MyNumber_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyNumber* tolua_ret = (MyNumber*)  Mtolua_new((MyNumber)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyNumber");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_new00_local
static int tolua_eTest_MyNumber_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyNumber* tolua_ret = (MyNumber*)  Mtolua_new((MyNumber)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyNumber");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_new01
static int tolua_eTest_MyNumber_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int iValue = ((int)  tolua_tonumber(tolua_S,2,0));
  float fValue = ((float)  tolua_tonumber(tolua_S,3,0));
  double dValue = ((double)  tolua_tonumber(tolua_S,4,0));
  {
   MyNumber* tolua_ret = (MyNumber*)  Mtolua_new((MyNumber)(iValue,fValue,dValue));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyNumber");
  }
 }
 return 1;
tolua_lerror:
 return tolua_eTest_MyNumber_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_new01_local
static int tolua_eTest_MyNumber_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int iValue = ((int)  tolua_tonumber(tolua_S,2,0));
  float fValue = ((float)  tolua_tonumber(tolua_S,3,0));
  double dValue = ((double)  tolua_tonumber(tolua_S,4,0));
  {
   MyNumber* tolua_ret = (MyNumber*)  Mtolua_new((MyNumber)(iValue,fValue,dValue));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyNumber");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_eTest_MyNumber_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_delete00
static int tolua_eTest_MyNumber_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetNumber_Int of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_SetNumber_Int00
static int tolua_eTest_MyNumber_SetNumber_Int00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
  int iValue = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetNumber_Int'", NULL);
#endif
  {
   self->SetNumber_Int(iValue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetNumber_Int'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetNumber_Float of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_SetNumber_Float00
static int tolua_eTest_MyNumber_SetNumber_Float00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
  float fValue = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetNumber_Float'", NULL);
#endif
  {
   self->SetNumber_Float(fValue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetNumber_Float'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetNumber_Double of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_SetNumber_Double00
static int tolua_eTest_MyNumber_SetNumber_Double00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
  double dValue = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetNumber_Double'", NULL);
#endif
  {
   self->SetNumber_Double(dValue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetNumber_Double'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumber_Int of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_GetNumber_Int00
static int tolua_eTest_MyNumber_GetNumber_Int00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumber_Int'", NULL);
#endif
  {
   int tolua_ret = (int)  self->GetNumber_Int();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumber_Int'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumber_Float of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_GetNumber_Float00
static int tolua_eTest_MyNumber_GetNumber_Float00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumber_Float'", NULL);
#endif
  {
   float tolua_ret = (float)  self->GetNumber_Float();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumber_Float'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumber_Double of class  MyNumber */
#ifndef TOLUA_DISABLE_tolua_eTest_MyNumber_GetNumber_Double00
static int tolua_eTest_MyNumber_GetNumber_Double00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyNumber",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyNumber* self = (MyNumber*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumber_Double'", NULL);
#endif
  {
   double tolua_ret = (double)  self->GetNumber_Double();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumber_Double'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_str of class  MyString */
#ifndef TOLUA_DISABLE_tolua_get_MyString_m_str
static int tolua_get_MyString_m_str(lua_State* tolua_S)
{
  MyString* self = (MyString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_str'",NULL);
#endif
  tolua_pushstring(tolua_S,(const char*)self->m_str);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_str of class  MyString */
#ifndef TOLUA_DISABLE_tolua_set_MyString_m_str
static int tolua_set_MyString_m_str(lua_State* tolua_S)
{
  MyString* self = (MyString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_str'",NULL);
  if (!tolua_isstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_str = ((char*)  tolua_tostring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyString */
#ifndef TOLUA_DISABLE_tolua_eTest_MyString_new00
static int tolua_eTest_MyString_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  char* pscStr = ((char*)  tolua_tostring(tolua_S,2,0));
  {
   MyString* tolua_ret = (MyString*)  Mtolua_new((MyString)(pscStr));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyString */
#ifndef TOLUA_DISABLE_tolua_eTest_MyString_new00_local
static int tolua_eTest_MyString_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  char* pscStr = ((char*)  tolua_tostring(tolua_S,2,0));
  {
   MyString* tolua_ret = (MyString*)  Mtolua_new((MyString)(pscStr));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  MyString */
#ifndef TOLUA_DISABLE_tolua_eTest_MyString_delete00
static int tolua_eTest_MyString_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyString* self = (MyString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetStr of class  MyString */
#ifndef TOLUA_DISABLE_tolua_eTest_MyString_SetStr00
static int tolua_eTest_MyString_SetStr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyString* self = (MyString*)  tolua_tousertype(tolua_S,1,0);
  char* pscStr = ((char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetStr'", NULL);
#endif
  {
   self->SetStr(pscStr);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetStr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetStr of class  MyString */
#ifndef TOLUA_DISABLE_tolua_eTest_MyString_GetStr00
static int tolua_eTest_MyString_GetStr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyString* self = (MyString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetStr'", NULL);
#endif
  {
   char* tolua_ret = (char*)  self->GetStr();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetStr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Init of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_Init00
static int tolua_eTest_LuaVM_Init00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Init'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->Init();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Init'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Init of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_Init01
static int tolua_eTest_LuaVM_Init01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  lua_State* pState =  tolua_S;
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Init'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->Init(pState);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_eTest_LuaVM_Init00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: UnInit of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_UnInit00
static int tolua_eTest_LuaVM_UnInit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UnInit'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->UnInit();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UnInit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ExecuteScriptFile of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_ExecuteScriptFile00
static int tolua_eTest_LuaVM_ExecuteScriptFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isuserdata(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  const char* FileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  void* pvOpenFile = ((void*)  tolua_touserdata(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteScriptFile'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->ExecuteScriptFile(FileName,pvOpenFile);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ExecuteScriptFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ExecuteScriptFromBuffer of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_ExecuteScriptFromBuffer00
static int tolua_eTest_LuaVM_ExecuteScriptFromBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  const char* FileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  char* pBuffer = ((char*)  tolua_tostring(tolua_S,3,0));
  size_t nSize = ((size_t)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteScriptFromBuffer'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->ExecuteScriptFromBuffer(FileName,pBuffer,nSize);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ExecuteScriptFromBuffer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CallFunctionBegin of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_CallFunctionBegin00
static int tolua_eTest_LuaVM_CallFunctionBegin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  int pIndex = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CallFunctionBegin'", NULL);
#endif
  {
   self->CallFunctionBegin(&pIndex);
   tolua_pushnumber(tolua_S,(lua_Number)pIndex);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CallFunctionBegin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CallFunctionEnd of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_CallFunctionEnd00
static int tolua_eTest_LuaVM_CallFunctionEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  int nIndex = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CallFunctionEnd'", NULL);
#endif
  {
   self->CallFunctionEnd(nIndex);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CallFunctionEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ExecuteString of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_ExecuteString00
static int tolua_eTest_LuaVM_ExecuteString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  const char* codes = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteString'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->ExecuteString(codes);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ExecuteString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: PushFunction of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_PushFunction00
static int tolua_eTest_LuaVM_PushFunction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  const char* pcsFunction = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'PushFunction'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->PushFunction(pcsFunction);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'PushFunction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CallFunction of class  LuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_LuaVM_CallFunction00
static int tolua_eTest_LuaVM_CallFunction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"LuaVM",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  LuaVM* self = (LuaVM*)  tolua_tousertype(tolua_S,1,0);
  int nArgs = ((int)  tolua_tonumber(tolua_S,2,0));
  int nResults = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CallFunction'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->CallFunction(nArgs,nResults);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CallFunction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__new00
static int tolua_eTest_MyTemplateArray_float__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyTemplateArray<float>* tolua_ret = (MyTemplateArray<float>*)  Mtolua_new((MyTemplateArray<float>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyTemplateArray<float>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__new00_local
static int tolua_eTest_MyTemplateArray_float__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyTemplateArray<float>* tolua_ret = (MyTemplateArray<float>*)  Mtolua_new((MyTemplateArray<float>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyTemplateArray<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__delete00
static int tolua_eTest_MyTemplateArray_float__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__clear00
static int tolua_eTest_MyTemplateArray_float__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float___seti00
static int tolua_eTest_MyTemplateArray_float___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t index = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
  float tolua_value = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float___geti00
static int tolua_eTest_MyTemplateArray_float___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t index = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   float tolua_ret = (float)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__remove00
static int tolua_eTest_MyTemplateArray_float__remove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t id = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   self->remove(id);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__size00
static int tolua_eTest_MyTemplateArray_float__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   uint32_t tolua_ret = (uint32_t)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__push_back00
static int tolua_eTest_MyTemplateArray_float__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
  float value = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: data of class  MyTemplateArray<float> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_float__data00
static int tolua_eTest_MyTemplateArray_float__data00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<float>* self = (MyTemplateArray<float>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'data'", NULL);
#endif
  {
   void* tolua_ret = (void*)  self->data();
   tolua_pushuserdata(tolua_S,(void*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__new00
static int tolua_eTest_MyTemplateArray_int__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyTemplateArray<int>* tolua_ret = (MyTemplateArray<int>*)  Mtolua_new((MyTemplateArray<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyTemplateArray<int>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__new00_local
static int tolua_eTest_MyTemplateArray_int__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyTemplateArray<int>* tolua_ret = (MyTemplateArray<int>*)  Mtolua_new((MyTemplateArray<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyTemplateArray<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__delete00
static int tolua_eTest_MyTemplateArray_int__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__clear00
static int tolua_eTest_MyTemplateArray_int__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int___seti00
static int tolua_eTest_MyTemplateArray_int___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t index = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
  int tolua_value = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int___geti00
static int tolua_eTest_MyTemplateArray_int___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t index = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   int tolua_ret = (int)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__remove00
static int tolua_eTest_MyTemplateArray_int__remove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t id = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   self->remove(id);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__size00
static int tolua_eTest_MyTemplateArray_int__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   uint32_t tolua_ret = (uint32_t)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__push_back00
static int tolua_eTest_MyTemplateArray_int__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
  int value = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: data of class  MyTemplateArray<int> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_int__data00
static int tolua_eTest_MyTemplateArray_int__data00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<int>* self = (MyTemplateArray<int>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'data'", NULL);
#endif
  {
   void* tolua_ret = (void*)  self->data();
   tolua_pushuserdata(tolua_S,(void*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__new00
static int tolua_eTest_MyTemplateArray_MyString__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyTemplateArray<MyString>* tolua_ret = (MyTemplateArray<MyString>*)  Mtolua_new((MyTemplateArray<MyString>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyTemplateArray<MyString>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__new00_local
static int tolua_eTest_MyTemplateArray_MyString__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyTemplateArray<MyString>* tolua_ret = (MyTemplateArray<MyString>*)  Mtolua_new((MyTemplateArray<MyString>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyTemplateArray<MyString>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__delete00
static int tolua_eTest_MyTemplateArray_MyString__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__clear00
static int tolua_eTest_MyTemplateArray_MyString__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString___seti00
static int tolua_eTest_MyTemplateArray_MyString___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"MyString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t index = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
  MyString tolua_value = *((MyString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString___geti00
static int tolua_eTest_MyTemplateArray_MyString___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t index = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   MyString tolua_ret = (MyString)  self->operator[](index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((MyString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"MyString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(MyString));
     tolua_pushusertype(tolua_S,tolua_obj,"MyString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__remove00
static int tolua_eTest_MyTemplateArray_MyString__remove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
  uint32_t id = ((uint32_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   self->remove(id);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__size00
static int tolua_eTest_MyTemplateArray_MyString__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   uint32_t tolua_ret = (uint32_t)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__push_back00
static int tolua_eTest_MyTemplateArray_MyString__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"MyString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
  MyString value = *((MyString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: data of class  MyTemplateArray<MyString> */
#ifndef TOLUA_DISABLE_tolua_eTest_MyTemplateArray_MyString__data00
static int tolua_eTest_MyTemplateArray_MyString__data00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyTemplateArray<MyString>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyTemplateArray<MyString>* self = (MyTemplateArray<MyString>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'data'", NULL);
#endif
  {
   MyString* tolua_ret = (MyString*)  self->data();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowFloatArray_StableLength of class  IArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_IArrayValue_ShowFloatArray_StableLength00
static int tolua_eTest_IArrayValue_ShowFloatArray_StableLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"IArrayValue",0,&tolua_err) ||
     !tolua_istable(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  IArrayValue* self = (IArrayValue*)  tolua_tousertype(tolua_S,1,0);
  float arr[3];
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowFloatArray_StableLength'", NULL);
#endif
  {
#ifndef TOLUA_RELEASE
   if (!tolua_isnumberarray(tolua_S,2,3,0,&tolua_err))
    goto tolua_lerror;
   else
#endif
   {
    int i;
    for(i=0; i<3;i++)
    arr[i] = ((float)  tolua_tofieldnumber(tolua_S,2,i+1,0));
   }
  }
  {
   self->ShowFloatArray_StableLength(arr);
  }
  {
   int i;
   for(i=0; i<3;i++)
    tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) arr[i]);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowFloatArray_StableLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowFloatArray_Improve of class  IArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_IArrayValue_ShowFloatArray_Improve00
static int tolua_eTest_IArrayValue_ShowFloatArray_Improve00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"IArrayValue",0,&tolua_err) ||
     !tolua_istable(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  IArrayValue* self = (IArrayValue*)  tolua_tousertype(tolua_S,1,0);
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
  float _arr[128];
  float* arr=_arr;
  if(len > 128)
    arr = new float[len];

#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowFloatArray_Improve'", NULL);
#endif
  {
#ifndef TOLUA_RELEASE
   if (!tolua_isnumberarray(tolua_S,2,0,0,&tolua_err))
    goto tolua_lerror;
   else
#endif
   {
    int i;
    for(i=0; i<len;i++)
    arr[i] = ((float)  tolua_tofieldnumber(tolua_S,2,i+1,0));
   }
  }
  {
   self->ShowFloatArray_Improve(arr,len);
  }
  {
   int i;
   for(i=0; i<len;i++)
    tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) arr[i]);
  }
  if(len > 128)
   delete[] arr; 

 }
 
return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowFloatArray_Improve'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_ArrayValue_new00
static int tolua_eTest_ArrayValue_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"ArrayValue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   ArrayValue* tolua_ret = (ArrayValue*)  Mtolua_new((ArrayValue)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"ArrayValue");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_ArrayValue_new00_local
static int tolua_eTest_ArrayValue_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"ArrayValue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   ArrayValue* tolua_ret = (ArrayValue*)  Mtolua_new((ArrayValue)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"ArrayValue");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_ArrayValue_delete00
static int tolua_eTest_ArrayValue_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"ArrayValue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  ArrayValue* self = (ArrayValue*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowFloatArray_StableLength of class  ArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_ArrayValue_ShowFloatArray_StableLength00
static int tolua_eTest_ArrayValue_ShowFloatArray_StableLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"ArrayValue",0,&tolua_err) ||
     !tolua_istable(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  ArrayValue* self = (ArrayValue*)  tolua_tousertype(tolua_S,1,0);
  float arr[3];
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowFloatArray_StableLength'", NULL);
#endif
  {
#ifndef TOLUA_RELEASE
   if (!tolua_isnumberarray(tolua_S,2,3,0,&tolua_err))
    goto tolua_lerror;
   else
#endif
   {
    int i;
    for(i=0; i<3;i++)
    arr[i] = ((float)  tolua_tofieldnumber(tolua_S,2,i+1,0));
   }
  }
  {
   self->ShowFloatArray_StableLength(arr);
  }
  {
   int i;
   for(i=0; i<3;i++)
    tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) arr[i]);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowFloatArray_StableLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowFloatArray_Quote of class  ArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_ArrayValue_ShowFloatArray_Quote00
static int tolua_eTest_ArrayValue_ShowFloatArray_Quote00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"ArrayValue",0,&tolua_err) ||
     !tolua_istable(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  ArrayValue* self = (ArrayValue*)  tolua_tousertype(tolua_S,1,0);
  float arr[3];
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowFloatArray_Quote'", NULL);
#endif
  {
#ifndef TOLUA_RELEASE
   if (!tolua_isnumberarray(tolua_S,2,3,0,&tolua_err))
    goto tolua_lerror;
   else
#endif
   {
    int i;
    for(i=0; i<3;i++)
    arr[i] = ((float)  tolua_tofieldnumber(tolua_S,2,i+1,0));
   }
  }
  {
   self->ShowFloatArray_Quote(arr);
  }
  {
   int i;
   for(i=0; i<3;i++)
    tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) arr[i]);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowFloatArray_Quote'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowFloatArray_Ptr of class  ArrayValue */
#ifndef TOLUA_DISABLE_tolua_eTest_ArrayValue_ShowFloatArray_Ptr00
static int tolua_eTest_ArrayValue_ShowFloatArray_Ptr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"ArrayValue",0,&tolua_err) ||
     !tolua_istable(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  ArrayValue* self = (ArrayValue*)  tolua_tousertype(tolua_S,1,0);
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
  float _arr[128];
  float* arr=_arr;
  if(len > 128)
    arr = new float[len];

#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowFloatArray_Ptr'", NULL);
#endif
  {
#ifndef TOLUA_RELEASE
   if (!tolua_isnumberarray(tolua_S,2,0,0,&tolua_err))
    goto tolua_lerror;
   else
#endif
   {
    int i;
    for(i=0; i<len;i++)
    arr[i] = ((float)  tolua_tofieldnumber(tolua_S,2,i+1,0));
   }
  }
  {
   self->ShowFloatArray_Ptr(arr,len);
  }
  {
   int i;
   for(i=0; i<len;i++)
    tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) arr[i]);
  }
  if(len > 128)
   delete[] arr; 

 }
 
return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowFloatArray_Ptr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_eTest_MyMessage_new00
static int tolua_eTest_MyMessage_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyMessage* tolua_ret = (MyMessage*)  Mtolua_new((MyMessage)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyMessage");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_eTest_MyMessage_new00_local
static int tolua_eTest_MyMessage_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MyMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   MyMessage* tolua_ret = (MyMessage*)  Mtolua_new((MyMessage)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"MyMessage");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_eTest_MyMessage_delete00
static int tolua_eTest_MyMessage_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyMessage* self = (MyMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowArray of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_eTest_MyMessage_ShowArray00
static int tolua_eTest_MyMessage_ShowArray00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"MyMessage",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"MyTemplateArray<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  MyMessage* self = (MyMessage*)  tolua_tousertype(tolua_S,1,0);
  MyTemplateArray<float>* value = ((MyTemplateArray<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowArray'", NULL);
#endif
  {
   self->ShowArray(*value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowArray'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_buff of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_get_MyMessage_m_buff
static int tolua_get_MyMessage_m_buff(lua_State* tolua_S)
{
  MyMessage* self = (MyMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_buff'",NULL);
#endif
  tolua_pushstring(tolua_S,(const char*)self->m_buff);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_buff of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_set_MyMessage_m_buff
static int tolua_set_MyMessage_m_buff(lua_State* tolua_S)
{
  MyMessage* self = (MyMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_buff'",NULL);
  if (!tolua_istable(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
 strncpy((char*)
self->m_buff,(const char*)tolua_tostring(tolua_S,2,0),256-1);
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_number of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_get_MyMessage_m_number
static int tolua_get_MyMessage_m_number(lua_State* tolua_S)
{
  MyMessage* self = (MyMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_number'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->m_number,"MyNumber");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_number of class  MyMessage */
#ifndef TOLUA_DISABLE_tolua_set_MyMessage_m_number
static int tolua_set_MyMessage_m_number(lua_State* tolua_S)
{
  MyMessage* self = (MyMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_number'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"MyNumber",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_number = *((MyNumber*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: Init of class  GameApplication */
#ifndef TOLUA_DISABLE_tolua_eTest_GameApplication_Init00
static int tolua_eTest_GameApplication_Init00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameApplication",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameApplication* self = (GameApplication*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Init'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->Init();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Init'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UnInit of class  GameApplication */
#ifndef TOLUA_DISABLE_tolua_eTest_GameApplication_UnInit00
static int tolua_eTest_GameApplication_UnInit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameApplication",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameApplication* self = (GameApplication*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UnInit'", NULL);
#endif
  {
   self->UnInit();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UnInit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ApplicationStart of class  GameApplication */
#ifndef TOLUA_DISABLE_tolua_eTest_GameApplication_ApplicationStart00
static int tolua_eTest_GameApplication_ApplicationStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameApplication",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameApplication* self = (GameApplication*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ApplicationStart'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->ApplicationStart();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ApplicationStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LoadScripts of class  GameApplication */
#ifndef TOLUA_DISABLE_tolua_eTest_GameApplication_LoadScripts00
static int tolua_eTest_GameApplication_LoadScripts00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameApplication",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameApplication* self = (GameApplication*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LoadScripts'", NULL);
#endif
  {
   self->LoadScripts();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LoadScripts'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIArrayValue of class  GameApplication */
#ifndef TOLUA_DISABLE_tolua_eTest_GameApplication_GetIArrayValue00
static int tolua_eTest_GameApplication_GetIArrayValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameApplication",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameApplication* self = (GameApplication*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIArrayValue'", NULL);
#endif
  {
   IArrayValue* tolua_ret = (IArrayValue*)  self->GetIArrayValue();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"IArrayValue");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIArrayValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: GetGameApplication */
#ifndef TOLUA_DISABLE_tolua_eTest_GetGameApplication00
static int tolua_eTest_GetGameApplication00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnoobj(tolua_S,1,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   GameApplication* tolua_ret = (GameApplication*)  GetGameApplication();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"GameApplication");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetGameApplication'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: LOG_D */
#ifndef TOLUA_DISABLE_tolua_eTest_LOG_D00
static int tolua_eTest_LOG_D00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* logStr = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   LOG_D(logStr);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LOG_D'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: LOG_I */
#ifndef TOLUA_DISABLE_tolua_eTest_LOG_I00
static int tolua_eTest_LOG_I00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* logStr = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   LOG_I(logStr);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LOG_I'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: LOG_W */
#ifndef TOLUA_DISABLE_tolua_eTest_LOG_W00
static int tolua_eTest_LOG_W00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* logStr = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   LOG_W(logStr);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LOG_W'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: LOG_E */
#ifndef TOLUA_DISABLE_tolua_eTest_LOG_E00
static int tolua_eTest_LOG_E00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* logStr = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   LOG_E(logStr);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LOG_E'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: g_GetLuaVM */
#ifndef TOLUA_DISABLE_tolua_eTest_g_GetLuaVM00
static int tolua_eTest_g_GetLuaVM00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnoobj(tolua_S,1,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   LuaVM* tolua_ret = (LuaVM*)  g_GetLuaVM();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"LuaVM");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'g_GetLuaVM'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: SpaceFunction::Space_GetPath */
#ifndef TOLUA_DISABLE_tolua_eTest_SpaceFunction_Space_GetPath00
static int tolua_eTest_SpaceFunction_Space_GetPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnoobj(tolua_S,1,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   const char* tolua_ret = (const char*)  SpaceFunction::Space_GetPath();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Space_GetPath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_eTest_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"LEVEL",0);
  tolua_beginmodule(tolua_S,"LEVEL");
   tolua_constant(tolua_S,"LOW",LEVEL::LOW);
   tolua_constant(tolua_S,"MID",LEVEL::MID);
   tolua_constant(tolua_S,"HIGHT",LEVEL::HIGHT);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MyNumber","MyNumber","",tolua_collect_MyNumber);
  #else
  tolua_cclass(tolua_S,"MyNumber","MyNumber","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MyNumber");
   tolua_variable(tolua_S,"m_Inumber",tolua_get_MyNumber_m_Inumber,tolua_set_MyNumber_m_Inumber);
   tolua_variable(tolua_S,"m_Fnumber",tolua_get_MyNumber_m_Fnumber,tolua_set_MyNumber_m_Fnumber);
   tolua_variable(tolua_S,"m_Dnumber",tolua_get_MyNumber_m_Dnumber,tolua_set_MyNumber_m_Dnumber);
   tolua_function(tolua_S,"new",tolua_eTest_MyNumber_new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyNumber_new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyNumber_new00_local);
   tolua_function(tolua_S,"new",tolua_eTest_MyNumber_new01);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyNumber_new01_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyNumber_new01_local);
   tolua_function(tolua_S,"delete",tolua_eTest_MyNumber_delete00);
   tolua_function(tolua_S,"SetNumber_Int",tolua_eTest_MyNumber_SetNumber_Int00);
   tolua_function(tolua_S,"SetNumber_Float",tolua_eTest_MyNumber_SetNumber_Float00);
   tolua_function(tolua_S,"SetNumber_Double",tolua_eTest_MyNumber_SetNumber_Double00);
   tolua_function(tolua_S,"GetNumber_Int",tolua_eTest_MyNumber_GetNumber_Int00);
   tolua_function(tolua_S,"GetNumber_Float",tolua_eTest_MyNumber_GetNumber_Float00);
   tolua_function(tolua_S,"GetNumber_Double",tolua_eTest_MyNumber_GetNumber_Double00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MyString","MyString","",tolua_collect_MyString);
  #else
  tolua_cclass(tolua_S,"MyString","MyString","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MyString");
   tolua_variable(tolua_S,"m_str",tolua_get_MyString_m_str,tolua_set_MyString_m_str);
   tolua_function(tolua_S,"new",tolua_eTest_MyString_new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyString_new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyString_new00_local);
   tolua_function(tolua_S,"delete",tolua_eTest_MyString_delete00);
   tolua_function(tolua_S,"SetStr",tolua_eTest_MyString_SetStr00);
   tolua_function(tolua_S,"GetStr",tolua_eTest_MyString_GetStr00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"LuaVM","LuaVM","",NULL);
  tolua_beginmodule(tolua_S,"LuaVM");
   tolua_function(tolua_S,"Init",tolua_eTest_LuaVM_Init00);
   tolua_function(tolua_S,"Init",tolua_eTest_LuaVM_Init01);
   tolua_function(tolua_S,"UnInit",tolua_eTest_LuaVM_UnInit00);
   tolua_function(tolua_S,"ExecuteScriptFile",tolua_eTest_LuaVM_ExecuteScriptFile00);
   tolua_function(tolua_S,"ExecuteScriptFromBuffer",tolua_eTest_LuaVM_ExecuteScriptFromBuffer00);
   tolua_function(tolua_S,"CallFunctionBegin",tolua_eTest_LuaVM_CallFunctionBegin00);
   tolua_function(tolua_S,"CallFunctionEnd",tolua_eTest_LuaVM_CallFunctionEnd00);
   tolua_function(tolua_S,"ExecuteString",tolua_eTest_LuaVM_ExecuteString00);
   tolua_function(tolua_S,"PushFunction",tolua_eTest_LuaVM_PushFunction00);
   tolua_function(tolua_S,"CallFunction",tolua_eTest_LuaVM_CallFunction00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MyTemplateArray_float_","MyTemplateArray<float>","",tolua_collect_MyTemplateArray_float_);
  #else
  tolua_cclass(tolua_S,"MyTemplateArray_float_","MyTemplateArray<float>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MyTemplateArray_float_");
   tolua_function(tolua_S,"new",tolua_eTest_MyTemplateArray_float__new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyTemplateArray_float__new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyTemplateArray_float__new00_local);
   tolua_function(tolua_S,"delete",tolua_eTest_MyTemplateArray_float__delete00);
   tolua_function(tolua_S,"clear",tolua_eTest_MyTemplateArray_float__clear00);
   tolua_function(tolua_S,".seti",tolua_eTest_MyTemplateArray_float___seti00);
   tolua_function(tolua_S,".geti",tolua_eTest_MyTemplateArray_float___geti00);
   tolua_function(tolua_S,"remove",tolua_eTest_MyTemplateArray_float__remove00);
   tolua_function(tolua_S,"size",tolua_eTest_MyTemplateArray_float__size00);
   tolua_function(tolua_S,"push_back",tolua_eTest_MyTemplateArray_float__push_back00);
   tolua_function(tolua_S,"data",tolua_eTest_MyTemplateArray_float__data00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MyTemplateArray_int_","MyTemplateArray<int>","",tolua_collect_MyTemplateArray_int_);
  #else
  tolua_cclass(tolua_S,"MyTemplateArray_int_","MyTemplateArray<int>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MyTemplateArray_int_");
   tolua_function(tolua_S,"new",tolua_eTest_MyTemplateArray_int__new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyTemplateArray_int__new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyTemplateArray_int__new00_local);
   tolua_function(tolua_S,"delete",tolua_eTest_MyTemplateArray_int__delete00);
   tolua_function(tolua_S,"clear",tolua_eTest_MyTemplateArray_int__clear00);
   tolua_function(tolua_S,".seti",tolua_eTest_MyTemplateArray_int___seti00);
   tolua_function(tolua_S,".geti",tolua_eTest_MyTemplateArray_int___geti00);
   tolua_function(tolua_S,"remove",tolua_eTest_MyTemplateArray_int__remove00);
   tolua_function(tolua_S,"size",tolua_eTest_MyTemplateArray_int__size00);
   tolua_function(tolua_S,"push_back",tolua_eTest_MyTemplateArray_int__push_back00);
   tolua_function(tolua_S,"data",tolua_eTest_MyTemplateArray_int__data00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MyTemplateArray_MyString_","MyTemplateArray<MyString>","",tolua_collect_MyTemplateArray_MyString_);
  #else
  tolua_cclass(tolua_S,"MyTemplateArray_MyString_","MyTemplateArray<MyString>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MyTemplateArray_MyString_");
   tolua_function(tolua_S,"new",tolua_eTest_MyTemplateArray_MyString__new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyTemplateArray_MyString__new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyTemplateArray_MyString__new00_local);
   tolua_function(tolua_S,"delete",tolua_eTest_MyTemplateArray_MyString__delete00);
   tolua_function(tolua_S,"clear",tolua_eTest_MyTemplateArray_MyString__clear00);
   tolua_function(tolua_S,".seti",tolua_eTest_MyTemplateArray_MyString___seti00);
   tolua_function(tolua_S,".geti",tolua_eTest_MyTemplateArray_MyString___geti00);
   tolua_function(tolua_S,"remove",tolua_eTest_MyTemplateArray_MyString__remove00);
   tolua_function(tolua_S,"size",tolua_eTest_MyTemplateArray_MyString__size00);
   tolua_function(tolua_S,"push_back",tolua_eTest_MyTemplateArray_MyString__push_back00);
   tolua_function(tolua_S,"data",tolua_eTest_MyTemplateArray_MyString__data00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"IArrayValue","IArrayValue","",NULL);
  tolua_beginmodule(tolua_S,"IArrayValue");
   tolua_function(tolua_S,"ShowFloatArray_StableLength",tolua_eTest_IArrayValue_ShowFloatArray_StableLength00);
   tolua_function(tolua_S,"ShowFloatArray_Improve",tolua_eTest_IArrayValue_ShowFloatArray_Improve00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ArrayValue","ArrayValue","",tolua_collect_ArrayValue);
  #else
  tolua_cclass(tolua_S,"ArrayValue","ArrayValue","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ArrayValue");
   tolua_function(tolua_S,"new",tolua_eTest_ArrayValue_new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_ArrayValue_new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_ArrayValue_new00_local);
   tolua_function(tolua_S,"delete",tolua_eTest_ArrayValue_delete00);
   tolua_function(tolua_S,"ShowFloatArray_StableLength",tolua_eTest_ArrayValue_ShowFloatArray_StableLength00);
   tolua_function(tolua_S,"ShowFloatArray_Quote",tolua_eTest_ArrayValue_ShowFloatArray_Quote00);
   tolua_function(tolua_S,"ShowFloatArray_Ptr",tolua_eTest_ArrayValue_ShowFloatArray_Ptr00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MyMessage","MyMessage","",tolua_collect_MyMessage);
  #else
  tolua_cclass(tolua_S,"MyMessage","MyMessage","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MyMessage");
   tolua_function(tolua_S,"new",tolua_eTest_MyMessage_new00);
   tolua_function(tolua_S,"new_local",tolua_eTest_MyMessage_new00_local);
   tolua_function(tolua_S,".call",tolua_eTest_MyMessage_new00_local);
   tolua_function(tolua_S,"delete",tolua_eTest_MyMessage_delete00);
   tolua_function(tolua_S,"ShowArray",tolua_eTest_MyMessage_ShowArray00);
   tolua_variable(tolua_S,"m_buff",tolua_get_MyMessage_m_buff,tolua_set_MyMessage_m_buff);
   tolua_variable(tolua_S,"m_number",tolua_get_MyMessage_m_number,tolua_set_MyMessage_m_number);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GameApplication","GameApplication","",NULL);
  tolua_beginmodule(tolua_S,"GameApplication");
   tolua_function(tolua_S,"Init",tolua_eTest_GameApplication_Init00);
   tolua_function(tolua_S,"UnInit",tolua_eTest_GameApplication_UnInit00);
   tolua_function(tolua_S,"ApplicationStart",tolua_eTest_GameApplication_ApplicationStart00);
   tolua_function(tolua_S,"LoadScripts",tolua_eTest_GameApplication_LoadScripts00);
   tolua_function(tolua_S,"GetIArrayValue",tolua_eTest_GameApplication_GetIArrayValue00);
  tolua_endmodule(tolua_S);
  tolua_function(tolua_S,"GetGameApplication",tolua_eTest_GetGameApplication00);
  tolua_function(tolua_S,"LOG_D",tolua_eTest_LOG_D00);
  tolua_function(tolua_S,"LOG_I",tolua_eTest_LOG_I00);
  tolua_function(tolua_S,"LOG_W",tolua_eTest_LOG_W00);
  tolua_function(tolua_S,"LOG_E",tolua_eTest_LOG_E00);
  tolua_function(tolua_S,"g_GetLuaVM",tolua_eTest_g_GetLuaVM00);
  tolua_module(tolua_S,"SpaceFunction",0);
  tolua_beginmodule(tolua_S,"SpaceFunction");
   tolua_function(tolua_S,"Space_GetPath",tolua_eTest_SpaceFunction_Space_GetPath00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_eTest (lua_State* tolua_S) {
 return tolua_eTest_open(tolua_S);
};
#endif

